/*--------------------------------------------------------------------------------------
 * 									Operador
 * 
 * Esta clase permite sumar o restar dos matrices.
 * 
 * Creada por: Ernesto Rodriguez, Josue Rendon, Byron Morales
 * -------------------------------------------------------------------------------------*/
public class Operador {

	
	//Este metodo suma dos matrices las cuales deben estar representadas como arreglos.
	//Este metodo se utiliza cuando las matrices tienen dos dimensiones
	//Los arreglos deben tener las mismas dimensiones que las matrices que representan
	public int[][] suma(Integer[][] op1, Integer[][] op2) throws ExcepcionSumaMatricesNoCompatibles{
					
		
		
		//Evalua si las dos matrices tienen el mismo largo
		if(op1.length!=op2.length)
			throw (new ExcepcionSumaMatricesNoCompatibles());
		
		//Evalua si las matrices tienen el mismo ancho
		if(op1[0].length!=op2[0].length)
			throw (new ExcepcionSumaMatricesNoCompatibles());
		
		//Respuesta almacenara la respuesda durante y despues de la operacion
		int[][] respuesta = new int[op1.length][op1[0].length];
		
		for(int veces=0; veces<op1.length; veces++)
			for(int veces1=0; veces1<op1[1].length; veces1++)
				respuesta[veces][veces1]=op1[veces][veces1]+op2[veces][veces1];
		
		return respuesta;
	}
		
	public int[][] resta(Integer[][] op1, Integer[][] op2) throws ExcepcionSumaMatricesNoCompatibles{
		
		if(op1.length!=op2.length)
			throw (new ExcepcionSumaMatricesNoCompatibles());
		
		if(op1[0].length!=op2[0].length)
			throw (new ExcepcionSumaMatricesNoCompatibles());
		
		int[][] respuesta = new int[op1.length][op1[0].length];
		
		for(int veces=0; veces<op1.length; veces++)
			for(int veces1=0; veces1<op1[0].length; veces1++)
				respuesta[veces][veces1]=op1[veces][veces1]-op2[veces][veces1];
		
		return respuesta;
	}
	
		
	public Integer[][] multiplicar (Integer[][] m1, Integer[][] m2) 
	    throws ExcepcionMultiplicacionMatricesNoCompatibles
	{
		/*
        System.out.println("Filas m1: " + m1.length + "\nColumnas m1: " 
                + m1[0].length + "\nFilas m2: " + m2.length + "\nColumnas m2: " 
                + m2[0].length);
	    */
	    
        if(m1[0].length != m2.length)
			throw (new ExcepcionMultiplicacionMatricesNoCompatibles());
		
		Integer [][] devolver = new Integer[ m1.length ][ m2[0].length ]; 
		int sumatoria;
		
		for (int i = 0; i < devolver.length; i++)
		{
			for (int j = 0; j < devolver[i].length; j++)
			{
				sumatoria = 0;
				for (int k = 0; k < m2.length; k++) {
				    /*
				    System.out.println("Fila (" + i + ")(" + k + "): " + 
			            m1[i][k] + "\nColumna (" + k + ")(" + j + "): " + 
			            m2[k][j]);
                     */
				        
					sumatoria += m1[i][k] * 
					        m2[k][j];
					
					// System.out.println("Sumatoria: " + sumatoria);
				}
				devolver[i][j] = sumatoria;
			}
		}
		return devolver;
	}
		
    public int[][] swapper(Integer[][] op1){

        //Esta matriz temporal se ira construyendo conforme se intercambian los numeros
        //Esta matriz tiene el mismo tamaño que la matriz original
        int[][] tmp = new int[op1[0].length][op1.length];

        //Este ciclo se encarga de recorrer toda la matriz
         for(int veces=0; veces<op1.length; veces++)
            for(int veces1=0; veces1<op1[0].length; veces1++){
                //Esta instruccion obtiene un valor de la matriz original y lo pone en la posicion opuesta de la matriz temporal.
                tmp[veces1][veces]=op1[veces][veces1];
        }
        
        return tmp;
    }
}